/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.lang;

import java.lang.reflect.AnnotatedElement;
import java.io.InputStream;
import java.util.Enumeration;

import java.util.StringTokenizer;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URL;
import java.net.MalformedURLException;
import java.security.AccessController;
import java.security.PrivilegedAction;

import java.util.jar.JarInputStream;
import java.util.jar.Manifest;
import java.util.jar.Attributes;
import java.util.jar.Attributes.Name;
import java.util.jar.JarException;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;

import sun.net.www.ParseUtil;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;

import java.lang.annotation.Annotation;

/**
 * {@code Package} objects contain version information
 * about the implementation and specification of a Java package.
 * This versioning information is retrieved and made available
 * by the {@link ClassLoader} instance that
 * loaded the class(es).  Typically, it is stored in the manifest that is
 * distributed with the classes.
 *
 * <p>The set of classes that make up the package may implement a
 * particular specification and if so the specification title, version number,
 * and vendor strings identify that specification.
 * An application can ask if the package is
 * compatible with a particular version, see the {@link
 * #isCompatibleWith isCompatibleWith}
 * method for details.
 *
 * <p>Specification version numbers use a syntax that consists of nonnegative
 * decimal integers separated by periods ".", for example "2.0" or
 * "1.2.3.4.5.6.7".  This allows an extensible number to be used to represent
 * major, minor, micro, etc. versions.  The version specification is described
 * by the following formal grammar:
 * <blockquote>
 * <dl>
 * <dt><i>SpecificationVersion:</i>
 * <dd><i>Digits RefinedVersion<sub>opt</sub></i>
 *
 * <dt><i>RefinedVersion:</i>
 * <dd>{@code .} <i>Digits</i>
 * <dd>{@code .} <i>Digits RefinedVersion</i>
 *
 * <dt><i>Digits:</i>
 * <dd><i>Digit</i>
 * <dd><i>Digits</i>
 *
 * <dt><i>Digit:</i>
 * <dd>any character for which {@link Character#isDigit} returns {@code true},
 * e.g. 0, 1, 2, ...
 * </dl>
 * </blockquote>
 *
 * <p>The implementation title, version, and vendor strings identify an
 * implementation and are made available conveniently to enable accurate
 * reporting of the packages involved when a problem occurs. The contents
 * all three implementation strings are vendor specific. The
 * implementation version strings have no specified syntax and should
 * only be compared for equality with desired version identifiers.
 *
 * <p>Within each {@code ClassLoader} instance all classes from the same
 * java package have the same Package object.  The static methods allow a package
 * to be found by name or the set of all packages known to the current class
 * loader to be found.
 *
 * @see ClassLoader#definePackage
 */
public class Package implements java.lang.reflect.AnnotatedElement {

  /**
   * Return the name of this package.
   *
   * @return The fully-qualified name of this package as defined in section 6.5.3 of <cite>The
   * Java&trade; Language Specification</cite>, for example, {@code java.lang}
   */
  public String getName() {
    return pkgName;
  }


  /**
   * Return the title of the specification that this package implements.
   *
   * @return the specification title, null is returned if it is not known.
   */
  public String getSpecificationTitle() {
    return specTitle;
  }

  /**
   * Returns the version number of the specification
   * that this package implements.
   * This version string must be a sequence of nonnegative decimal
   * integers separated by "."'s and may have leading zeros.
   * When version strings are compared the most significant
   * numbers are compared.
   *
   * @return the specification version, null is returned if it is not known.
   */
  public String getSpecificationVersion() {
    return specVersion;
  }

  /**
   * Return the name of the organization, vendor,
   * or company that owns and maintains the specification
   * of the classes that implement this package.
   *
   * @return the specification vendor, null is returned if it is not known.
   */
  public String getSpecificationVendor() {
    return specVendor;
  }

  /**
   * Return the title of this package.
   *
   * @return the title of the implementation, null is returned if it is not known.
   */
  public String getImplementationTitle() {
    return implTitle;
  }

  /**
   * Return the version of this implementation. It consists of any string
   * assigned by the vendor of this implementation and does
   * not have any particular syntax specified or expected by the Java
   * runtime. It may be compared for equality with other
   * package version strings used for this implementation
   * by this vendor for this package.
   *
   * @return the version of the implementation, null is returned if it is not known.
   */
  public String getImplementationVersion() {
    return implVersion;
  }

  /**
   * Returns the name of the organization,
   * vendor or company that provided this implementation.
   *
   * @return the vendor that implemented this package..
   */
  public String getImplementationVendor() {
    return implVendor;
  }

  /**
   * Returns true if this package is sealed.
   *
   * @return true if the package is sealed, false otherwise
   */
  public boolean isSealed() {
    return sealBase != null;
  }

  /**
   * Returns true if this package is sealed with respect to the specified
   * code source url.
   *
   * @param url the code source url
   * @return true if this package is sealed with respect to url
   */
  public boolean isSealed(URL url) {
    return url.equals(sealBase);
  }

  /**
   * Compare this package's specification version with a
   * desired version. It returns true if
   * this packages specification version number is greater than or equal
   * to the desired version number. <p>
   *
   * Version numbers are compared by sequentially comparing corresponding
   * components of the desired and specification strings.
   * Each component is converted as a decimal integer and the values
   * compared.
   * If the specification value is greater than the desired
   * value true is returned. If the value is less false is returned.
   * If the values are equal the period is skipped and the next pair of
   * components is compared.
   *
   * @param desired the version string of the desired version.
   * @return true if this package's version number is greater than or equal to the desired version
   * number
   * @throws NumberFormatException if the desired or current version is not of the correct dotted
   * form.
   */
  public boolean isCompatibleWith(String desired)
      throws NumberFormatException {
    if (specVersion == null || specVersion.length() < 1) {
      throw new NumberFormatException("Empty version string");
    }

    String[] sa = specVersion.split("\\.", -1);
    int[] si = new int[sa.length];
    for (int i = 0; i < sa.length; i++) {
      si[i] = Integer.parseInt(sa[i]);
      if (si[i] < 0) {
        throw NumberFormatException.forInputString("" + si[i]);
      }
    }

    String[] da = desired.split("\\.", -1);
    int[] di = new int[da.length];
    for (int i = 0; i < da.length; i++) {
      di[i] = Integer.parseInt(da[i]);
      if (di[i] < 0) {
        throw NumberFormatException.forInputString("" + di[i]);
      }
    }

    int len = Math.max(di.length, si.length);
    for (int i = 0; i < len; i++) {
      int d = (i < di.length ? di[i] : 0);
      int s = (i < si.length ? si[i] : 0);
      if (s < d) {
        return false;
      }
      if (s > d) {
        return true;
      }
    }
    return true;
  }

  /**
   * Find a package by name in the callers {@code ClassLoader} instance.
   * The callers {@code ClassLoader} instance is used to find the package
   * instance corresponding to the named class. If the callers
   * {@code ClassLoader} instance is null then the set of packages loaded
   * by the system {@code ClassLoader} instance is searched to find the
   * named package. <p>
   *
   * Packages have attributes for versions and specifications only if the class
   * loader created the package instance with the appropriate attributes. Typically,
   * those attributes are defined in the manifests that accompany the classes.
   *
   * @param name a package name, for example, java.lang.
   * @return the package of the requested name. It may be null if no package information is
   * available from the archive or codebase.
   */
  @CallerSensitive
  public static Package getPackage(String name) {
    ClassLoader l = ClassLoader.getClassLoader(Reflection.getCallerClass());
    if (l != null) {
      return l.getPackage(name);
    } else {
      return getSystemPackage(name);
    }
  }

  /**
   * Get all the packages currently known for the caller's {@code ClassLoader}
   * instance.  Those packages correspond to classes loaded via or accessible by
   * name to that {@code ClassLoader} instance.  If the caller's
   * {@code ClassLoader} instance is the bootstrap {@code ClassLoader}
   * instance, which may be represented by {@code null} in some implementations,
   * only packages corresponding to classes loaded by the bootstrap
   * {@code ClassLoader} instance will be returned.
   *
   * @return a new array of packages known to the callers {@code ClassLoader} instance.  An zero
   * length array is returned if none are known.
   */
  @CallerSensitive
  public static Package[] getPackages() {
    ClassLoader l = ClassLoader.getClassLoader(Reflection.getCallerClass());
    if (l != null) {
      return l.getPackages();
    } else {
      return getSystemPackages();
    }
  }

  /**
   * Get the package for the specified class.
   * The class's class loader is used to find the package instance
   * corresponding to the specified class. If the class loader
   * is the bootstrap class loader, which may be represented by
   * {@code null} in some implementations, then the set of packages
   * loaded by the bootstrap class loader is searched to find the package.
   * <p>
   * Packages have attributes for versions and specifications only
   * if the class loader created the package
   * instance with the appropriate attributes. Typically those
   * attributes are defined in the manifests that accompany
   * the classes.
   *
   * @param c the class to get the package of.
   * @return the package of the class. It may be null if no package information is available from
   * the archive or codebase.
   */
  static Package getPackage(Class<?> c) {
    String name = c.getName();
    int i = name.lastIndexOf('.');
    if (i != -1) {
      name = name.substring(0, i);
      ClassLoader cl = c.getClassLoader();
      if (cl != null) {
        return cl.getPackage(name);
      } else {
        return getSystemPackage(name);
      }
    } else {
      return null;
    }
  }

  /**
   * Return the hash code computed from the package name.
   *
   * @return the hash code computed from the package name.
   */
  public int hashCode() {
    return pkgName.hashCode();
  }

  /**
   * Returns the string representation of this Package.
   * Its value is the string "package " and the package name.
   * If the package title is defined it is appended.
   * If the package version is defined it is appended.
   *
   * @return the string representation of the package.
   */
  public String toString() {
    String spec = specTitle;
    String ver = specVersion;
    if (spec != null && spec.length() > 0) {
      spec = ", " + spec;
    } else {
      spec = "";
    }
    if (ver != null && ver.length() > 0) {
      ver = ", version " + ver;
    } else {
      ver = "";
    }
    return "package " + pkgName + spec + ver;
  }

  private Class<?> getPackageInfo() {
    if (packageInfo == null) {
      try {
        packageInfo = Class.forName(pkgName + ".package-info", false, loader);
      } catch (ClassNotFoundException ex) {
        // store a proxy for the package info that has no annotations
        class PackageInfoProxy {

        }
        packageInfo = PackageInfoProxy.class;
      }
    }
    return packageInfo;
  }

  /**
   * @throws NullPointerException {@inheritDoc}
   * @since 1.5
   */
  public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
    return getPackageInfo().getAnnotation(annotationClass);
  }

  /**
   * {@inheritDoc}
   *
   * @throws NullPointerException {@inheritDoc}
   * @since 1.5
   */
  @Override
  public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
    return AnnotatedElement.super.isAnnotationPresent(annotationClass);
  }

  /**
   * @throws NullPointerException {@inheritDoc}
   * @since 1.8
   */
  @Override
  public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass) {
    return getPackageInfo().getAnnotationsByType(annotationClass);
  }

  /**
   * @since 1.5
   */
  public Annotation[] getAnnotations() {
    return getPackageInfo().getAnnotations();
  }

  /**
   * @throws NullPointerException {@inheritDoc}
   * @since 1.8
   */
  @Override
  public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass) {
    return getPackageInfo().getDeclaredAnnotation(annotationClass);
  }

  /**
   * @throws NullPointerException {@inheritDoc}
   * @since 1.8
   */
  @Override
  public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationClass) {
    return getPackageInfo().getDeclaredAnnotationsByType(annotationClass);
  }

  /**
   * @since 1.5
   */
  public Annotation[] getDeclaredAnnotations() {
    return getPackageInfo().getDeclaredAnnotations();
  }

  /**
   * Construct a package instance with the specified version
   * information.
   *
   * @param name the name of the package
   * @param spectitle the title of the specification
   * @param specversion the version of the specification
   * @param specvendor the organization that maintains the specification
   * @param impltitle the title of the implementation
   * @param implversion the version of the implementation
   * @param implvendor the organization that maintains the implementation
   */
  Package(String name,
      String spectitle, String specversion, String specvendor,
      String impltitle, String implversion, String implvendor,
      URL sealbase, ClassLoader loader) {
    pkgName = name;
    implTitle = impltitle;
    implVersion = implversion;
    implVendor = implvendor;
    specTitle = spectitle;
    specVersion = specversion;
    specVendor = specvendor;
    sealBase = sealbase;
    this.loader = loader;
  }

  /*
   * Construct a package using the attributes from the specified manifest.
   *
   * @param name the package name
   * @param man the optional manifest for the package
   * @param url the optional code source url for the package
   */
  private Package(String name, Manifest man, URL url, ClassLoader loader) {
    String path = name.replace('.', '/').concat("/");
    String sealed = null;
    String specTitle = null;
    String specVersion = null;
    String specVendor = null;
    String implTitle = null;
    String implVersion = null;
    String implVendor = null;
    URL sealBase = null;
    Attributes attr = man.getAttributes(path);
    if (attr != null) {
      specTitle = attr.getValue(Name.SPECIFICATION_TITLE);
      specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
      specVendor = attr.getValue(Name.SPECIFICATION_VENDOR);
      implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE);
      implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
      implVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR);
      sealed = attr.getValue(Name.SEALED);
    }
    attr = man.getMainAttributes();
    if (attr != null) {
      if (specTitle == null) {
        specTitle = attr.getValue(Name.SPECIFICATION_TITLE);
      }
      if (specVersion == null) {
        specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
      }
      if (specVendor == null) {
        specVendor = attr.getValue(Name.SPECIFICATION_VENDOR);
      }
      if (implTitle == null) {
        implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE);
      }
      if (implVersion == null) {
        implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
      }
      if (implVendor == null) {
        implVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR);
      }
      if (sealed == null) {
        sealed = attr.getValue(Name.SEALED);
      }
    }
    if ("true".equalsIgnoreCase(sealed)) {
      sealBase = url;
    }
    pkgName = name;
    this.specTitle = specTitle;
    this.specVersion = specVersion;
    this.specVendor = specVendor;
    this.implTitle = implTitle;
    this.implVersion = implVersion;
    this.implVendor = implVendor;
    this.sealBase = sealBase;
    this.loader = loader;
  }

  /*
   * Returns the loaded system package for the specified name.
   */
  static Package getSystemPackage(String name) {
    synchronized (pkgs) {
      Package pkg = pkgs.get(name);
      if (pkg == null) {
        name = name.replace('.', '/').concat("/");
        String fn = getSystemPackage0(name);
        if (fn != null) {
          pkg = defineSystemPackage(name, fn);
        }
      }
      return pkg;
    }
  }

  /*
   * Return an array of loaded system packages.
   */
  static Package[] getSystemPackages() {
    // First, update the system package map with new package names
    String[] names = getSystemPackages0();
    synchronized (pkgs) {
      for (int i = 0; i < names.length; i++) {
        defineSystemPackage(names[i], getSystemPackage0(names[i]));
      }
      return pkgs.values().toArray(new Package[pkgs.size()]);
    }
  }

  private static Package defineSystemPackage(final String iname,
      final String fn) {
    return AccessController.doPrivileged(new PrivilegedAction<Package>() {
      public Package run() {
        String name = iname;
        // Get the cached code source url for the file name
        URL url = urls.get(fn);
        if (url == null) {
          // URL not found, so create one
          File file = new File(fn);
          try {
            url = ParseUtil.fileToEncodedURL(file);
          } catch (MalformedURLException e) {
          }
          if (url != null) {
            urls.put(fn, url);
            // If loading a JAR file, then also cache the manifest
            if (file.isFile()) {
              mans.put(fn, loadManifest(fn));
            }
          }
        }
        // Convert to "."-separated package name
        name = name.substring(0, name.length() - 1).replace('/', '.');
        Package pkg;
        Manifest man = mans.get(fn);
        if (man != null) {
          pkg = new Package(name, man, url, null);
        } else {
          pkg = new Package(name, null, null, null,
              null, null, null, null, null);
        }
        pkgs.put(name, pkg);
        return pkg;
      }
    });
  }

  /*
   * Returns the Manifest for the specified JAR file name.
   */
  private static Manifest loadManifest(String fn) {
    try (FileInputStream fis = new FileInputStream(fn);
        JarInputStream jis = new JarInputStream(fis, false)) {
      return jis.getManifest();
    } catch (IOException e) {
      return null;
    }
  }

  // The map of loaded system packages
  private static Map<String, Package> pkgs = new HashMap<>(31);

  // Maps each directory or zip file name to its corresponding url
  private static Map<String, URL> urls = new HashMap<>(10);

  // Maps each code source url for a jar file to its manifest
  private static Map<String, Manifest> mans = new HashMap<>(10);

  private static native String getSystemPackage0(String name);

  private static native String[] getSystemPackages0();

  /*
   * Private storage for the package name and attributes.
   */
  private final String pkgName;
  private final String specTitle;
  private final String specVersion;
  private final String specVendor;
  private final String implTitle;
  private final String implVersion;
  private final String implVendor;
  private final URL sealBase;
  private transient final ClassLoader loader;
  private transient Class<?> packageInfo;
}
